jet.h File Reference

#include <cmath>
#include <complex>
#include <iosfwd>
#include <iostream>
#include <limits>
#include <numeric>
#include <string>
#include <type_traits>
#include "Eigen/Core"
#include "core/math/autodiff/internal/jet_traits.h"
#include "core/math/autodiff/internal/port.h"
#include "core/math/autodiff/jet_fwd.h"

Go to the source code of this file.

Classes
struct	std::common_type< T, wolf::autodiff::Jet< U, N > >
struct	std::common_type< wolf::autodiff::Jet< T, N >, U >
struct	std::common_type< wolf::autodiff::Jet< T, N >, wolf::autodiff::Jet< U, N > >
struct	wolf::autodiff::Jet< T, N >
struct	std::numeric_limits< wolf::autodiff::Jet< T, N > >
struct	Eigen::NumTraits< wolf::autodiff::Jet< T, N > >
struct	Eigen::NumTraits< wolf::autodiff::Jet< T, N > >::Div< Vectorized >
struct	Eigen::ScalarBinaryOpTraits< wolf::autodiff::Jet< T, N >, T, BinaryOp >
struct	Eigen::ScalarBinaryOpTraits< T, wolf::autodiff::Jet< T, N >, BinaryOp >

Namespaces
namespace	wolf
namespace	wolf::autodiff
namespace	std
namespace	Eigen
	Namespace extending Eigen definitions.

Macros
#define	WOLF_AUTODIFF_DEFINE_JET_COMPARISON_OPERATOR(op)

Functions
template<typename T , int N>
Jet< T, N > const &	wolf::autodiff::operator+ (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator- (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator+ (const Jet< T, N > &f, const Jet< T, N > &g)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator+ (const Jet< T, N > &f, T s)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator+ (T s, const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator- (const Jet< T, N > &f, const Jet< T, N > &g)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator- (const Jet< T, N > &f, T s)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator- (T s, const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator* (const Jet< T, N > &f, const Jet< T, N > &g)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator* (const Jet< T, N > &f, T s)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator* (T s, const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator/ (const Jet< T, N > &f, const Jet< T, N > &g)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator/ (T s, const Jet< T, N > &g)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::operator/ (const Jet< T, N > &f, T s)
	wolf::autodiff::WOLF_AUTODIFF_DEFINE_JET_COMPARISON_OPERATOR (<) WOLF_AUTODIFF_DEFINE_JET_COMPARISON_OPERATOR(<
bool	wolf::autodiff::IsFinite (double x)
bool	wolf::autodiff::IsInfinite (double x)
bool	wolf::autodiff::IsNaN (double x)
bool	wolf::autodiff::IsNormal (double x)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::abs (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::copysign (const Jet< T, N > &f, const Jet< T, N > g)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::log (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::log10 (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::log1p (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::exp (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::expm1 (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::sqrt (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::cos (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::acos (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::sin (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::asin (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::tan (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::atan (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::sinh (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::cosh (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::tanh (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::floor (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::ceil (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::cbrt (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::exp2 (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::log2 (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::hypot (const Jet< T, N > &x, const Jet< T, N > &y)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::hypot (const Jet< T, N > &x, const Jet< T, N > &y, const Jet< T, N > &z)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::fma (const Jet< T, N > &x, const Jet< T, N > &y, const Jet< T, N > &z)
template<typename Lhs , typename Rhs , std::enable_if_t< CompatibleJetOperands_v< Lhs, Rhs > > * = nullptr>
decltype(auto)	wolf::autodiff::fmax (const Lhs &x, const Rhs &y)
template<typename Lhs , typename Rhs , std::enable_if_t< CompatibleJetOperands_v< Lhs, Rhs > > * = nullptr>
decltype(auto)	wolf::autodiff::fmin (const Lhs &x, const Rhs &y)
template<typename Lhs , typename Rhs , std::enable_if_t< CompatibleJetOperands_v< Lhs, Rhs > > * = nullptr>
decltype(auto)	wolf::autodiff::fdim (const Lhs &f, const Rhs &g)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::erf (const Jet< T, N > &x)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::erfc (const Jet< T, N > &x)
double	wolf::autodiff::BesselJ0 (double x)
double	wolf::autodiff::BesselJ1 (double x)
double	wolf::autodiff::BesselJn (int n, double x)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::BesselJ0 (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::BesselJ1 (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::BesselJn (int n, const Jet< T, N > &f)
template<typename T , int N>
bool	wolf::autodiff::isfinite (const Jet< T, N > &f)
template<typename T , int N>
bool	wolf::autodiff::isinf (const Jet< T, N > &f)
template<typename T , int N>
bool	wolf::autodiff::isnan (const Jet< T, N > &f)
template<typename T , int N>
bool	wolf::autodiff::isnormal (const Jet< T, N > &f)
template<typename Lhs , typename Rhs , std::enable_if_t< CompatibleJetOperands_v< Lhs, Rhs > > * = nullptr>
bool	wolf::autodiff::isless (const Lhs &f, const Rhs &g)
template<typename Lhs , typename Rhs , std::enable_if_t< CompatibleJetOperands_v< Lhs, Rhs > > * = nullptr>
bool	wolf::autodiff::isgreater (const Lhs &f, const Rhs &g)
template<typename Lhs , typename Rhs , std::enable_if_t< CompatibleJetOperands_v< Lhs, Rhs > > * = nullptr>
bool	wolf::autodiff::islessequal (const Lhs &f, const Rhs &g)
template<typename Lhs , typename Rhs , std::enable_if_t< CompatibleJetOperands_v< Lhs, Rhs > > * = nullptr>
bool	wolf::autodiff::islessgreater (const Lhs &f, const Rhs &g)
template<typename Lhs , typename Rhs , std::enable_if_t< CompatibleJetOperands_v< Lhs, Rhs > > * = nullptr>
bool	wolf::autodiff::isgreaterequal (const Lhs &f, const Rhs &g)
template<typename Lhs , typename Rhs , std::enable_if_t< CompatibleJetOperands_v< Lhs, Rhs > > * = nullptr>
bool	wolf::autodiff::isunordered (const Lhs &f, const Rhs &g)
template<typename T , int N>
int	wolf::autodiff::fpclassify (const Jet< T, N > &f)
template<typename T , int N>
bool	wolf::autodiff::signbit (const Jet< T, N > &f)
template<typename T , int N>
	wolf::autodiff::WOLF_AUTODIFF_DEPRECATED_WITH_MSG ("wolf::autodiff::IsFinite will be removed in a future Ceres Solver release. Please " "use wolf::autodiff::isfinite.") inline bool IsFinite(const Jet< T
template<typename T , int N>
	wolf::autodiff::WOLF_AUTODIFF_DEPRECATED_WITH_MSG ("wolf::autodiff::IsNaN will be removed in a future Ceres Solver release. Please use " "wolf::autodiff::isnan.") inline bool IsNaN(const Jet< T
template<typename T , int N>
	wolf::autodiff::WOLF_AUTODIFF_DEPRECATED_WITH_MSG ("wolf::autodiff::IsNormal will be removed in a future Ceres Solver release. Please " "use wolf::autodiff::isnormal.") inline bool IsNormal(const Jet< T
template<typename T , int N>
	wolf::autodiff::WOLF_AUTODIFF_DEPRECATED_WITH_MSG ("wolf::autodiff::IsInfinite will be removed in a future Ceres Solver release. " "Please use wolf::autodiff::isinf.") inline bool IsInfinite(const Jet< T
template<typename T , int N>
Jet< T, N >	wolf::autodiff::atan2 (const Jet< T, N > &g, const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::norm (const Jet< T, N > &f)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::pow (const Jet< T, N > &f, double g)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::pow (T f, const Jet< T, N > &g)
template<typename T , int N>
Jet< T, N >	wolf::autodiff::pow (const Jet< T, N > &f, const Jet< T, N > &g)
template<typename T , int N>
std::ostream &	wolf::autodiff::operator<< (std::ostream &s, const Jet< T, N > &z)

Variables
N &	wolf::autodiff::f

Macro Definition Documentation

WOLF_AUTODIFF_DEFINE_JET_COMPARISON_OPERATOR

#define WOLF_AUTODIFF_DEFINE_JET_COMPARISON_OPERATOR

(

op

)

Value:

  template <typename Lhs,                                                   \
            typename Rhs,                                                   \
            std::enable_if_t<PromotableJetOperands_v<Lhs, Rhs>>* = nullptr> \
  constexpr bool operator op(const Lhs& f, const Rhs& g) noexcept(          \
      noexcept(internal::AsScalar(f) op internal::AsScalar(g))) {           \
    using internal::AsScalar;                                               \
    return AsScalar(f) op AsScalar(g);                                      \
  }